////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afdtuning.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFDTUNING_H
#define AFDTUNING_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "globalelements.h"

#define AFDTUNING_NAMESPACE_BEGIN namespace afdTuning {
#define AFDTUNING_NAMESPACE_END }

AFDTUNING_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// trigger_point_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct trigger_point_type
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lux_index_start
    ///
    /// Description:   Lux index based trigger point: start
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT64 lux_index_start;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lux_index_end
    ///
    /// Description:   Lux index based trigger point: end
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT64 lux_index_end;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_afd_rolling_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_afd_rolling_data_type
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// std_threshold
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Peak distance standard deviation threshold
    /// Range:         [0.1,0.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  std_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// percent_threshold
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Percentage of peaks rolling in same direction threshold, when FOV is small and there is only one peak per
    ///                frame
    /// Range:         [40,60]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  percent_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// diff_threshold
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Differential threshold to detect a peak
    /// Range:         [10,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT64 diff_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_peaks_threshold
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Number of peaks to detect to declare flicker
    /// Range:         [2,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  num_peaks_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// band_dist_comp
    ///
    /// Tuning Level:  never_tune
    /// Description:   Peak distance must be at least computed distance * band_dist_comp to be considered
    /// Range:         [0.8,0.95]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  band_dist_comp;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// band_range_min
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   To decide flicker or not: peak width range min
    /// Range:         [0.8,0.9]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  band_range_min;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// band_range_max
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   To decide flicker or not: peak width range max
    /// Range:         [1.1,1.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  band_range_max;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_afd_scd_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_afd_scd_data_type
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sad_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Frame to frame difference threshold
    /// Range:         [20,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 sad_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sadr_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   First frame to current 5 frame difference threshold
    /// Range:         [20,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 sadr_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sad_max_frame
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many frame scene detection should use
    /// Range:         [1,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 sad_max_frame;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_afd_static_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_afd_static_data_type
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldLevel2Ratio
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Energy ratio threshold for level 2, Q8 format
    /// Range:         [240,256]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldLevel2Ratio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldLevel3Ratio
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Energy ratio threshold for level 3, Q8 format
    /// Range:         [235,250]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldLevel3Ratio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldLevel2Col
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many columns need to detect flicker in level 2
    /// Range:         [1,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldLevel2Col;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldLevel3Col
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many columns need to detect flicker in level 3
    /// Range:         [1,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldLevel3Col;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldEkL
    ///
    /// Tuning Level:  never_tune
    /// Description:   lower energy threshold of k_th level processing, Q10 format
    /// Range:         [6144,7168]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldEkL;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldEkU
    ///
    /// Tuning Level:  never_tune
    /// Description:   lower energy threshold of k_th level processing, Q10 format
    /// Range:         [102400,131072]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldEkU;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldCounterL3
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Positive frame counter threshold for level 3 detection
    /// Range:         [1,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldCounterL3;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thldCounterL2
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Positive frame counter threshold for level 2 detection
    /// Range:         [4,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thldCounterL2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LevelDepth
    ///
    /// Tuning Level:  never_tune
    /// Description:   Decides whether process only level 3 or both level 2 and 3
    /// Range:         [2,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 LevelDepth;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_step_size
    ///
    /// Tuning Level:  never_tune
    /// Description:   Moving window step size
    /// Range:         [4,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_step_size;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_down_size
    ///
    /// Tuning Level:  never_tune
    /// Description:   Data downsampling rate
    /// Range:         [2,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_down_size;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_k_step
    ///
    /// Tuning Level:  never_tune
    /// Description:   Fourier series decomposition level
    /// Range:         [4,12]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_k_step;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_slope_steep_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When linear regression slope is steeper we will not consider that data. Default value Q16
    /// Range:         [150000,350000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_slope_steep_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_slope_not_steep_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When linear regression slope is lower we will boost energy ratio. Default value Q16
    /// Range:         [8192,65536]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_slope_not_steep_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_confidence_level_slope_ratio
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   when linear regression is not steep: boost energy ratio that indicates static bands
    /// Range:         [1.1,1.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT static_confidence_level_slope_ratio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_confidence_thr_h
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   High threshold for signal to determine confidence
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_confidence_thr_h;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_confidence_thr_l
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Low threshold for signal to determine confidence
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_confidence_thr_l;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_confidence_ratio_h
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How much ratio will be applied for high threshold
    /// Range:         [1.0,1.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT static_confidence_ratio_h;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_confidence_ratio_l
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How much ratio will be applied for low threshold
    /// Range:         [1.0,1.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT static_confidence_ratio_l;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_low_rowsum_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When rowsum values are lower than this threshold, increase rowsum data itself
    /// Default Value: 5000
    /// Range:         [4000,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_low_rowsum_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// static_low_rowsum_comp
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When rowsum values are lower than static_low_rowsum_thr apply this compensation gain
    /// Range:         [1,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 static_low_rowsum_comp;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_auto_flicker_detection_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_auto_flicker_detection_data_type
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
        INT32 incr_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_ct_threshold
    ///
    /// Tuning Level:  often_tune
    /// Description:   Number of frames before AFD algorithm starts
    /// Range:         [1,500]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT64                          frame_ct_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_smooth_detection_thr
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   After certain frames, detection rate is slower
    /// Range:         [10,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           frame_smooth_detection_thr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_smooth_ct_threshold
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   After certain frames, detection rate is slower. Recommended value: double frame_smooth_detection_thr
    /// Range:         [20,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           frame_smooth_ct_threshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_frames
    ///
    /// Tuning Level:  never_tune
    /// Description:   How many frames to gather before performing analysis
    /// Range:         [5,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           num_frames;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_skip
    ///
    /// Tuning Level:  never_tune
    /// Description:   Detecting flicker by comparing frame N to frame N + skip
    /// Range:         [1,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           frame_skip;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_rows
    ///
    /// Tuning Level:  never_tune
    /// Description:   Number of rows in rowsum stats
    /// Range:         [300,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           num_rows;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_cols
    ///
    /// Tuning Level:  never_tune
    /// Description:   Number of column regions in rowsum stats
    /// Range:         [4,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           num_cols;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// switch_on_first_detection
    ///
    /// Tuning Level:  often_tune
    /// Description:   AFD detection 2 times to reduce false positive for extreme cases. ex. PIP or low band number
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                            switch_on_first_detection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// max_attempts_for_second_detection
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many frames to be said it is detected twice.
    /// Range:         [0,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           max_attempts_for_second_detection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFD_continuous_enable
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Will keep AFD algorithm running during camera session
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                            AFD_continuous_enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_frames_settle
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   max frame count for new AFD setting to take effect
    /// Range:         [1,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           num_frames_settle;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// start_antbanding_table
    ///
    /// Tuning Level:  often_tune
    /// Description:   Start state: either 60Hz or 50Hz
    /// Range:         [50,60]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                           start_antbanding_table;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// max_exp_time_ms
    ///
    /// Tuning Level:  never_tune
    /// Description:   Max exp time we still do AFD, in ms,
    /// Range:         [8.3,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                           max_exp_time_ms;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_low_light_trigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    trigger_point_type              afd_low_light_trigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_rolling_normal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_rolling_data_type afd_rolling_normal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_rolling_lowlight
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_rolling_data_type afd_rolling_lowlight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_static_normal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_static_data_type  afd_static_normal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_static_lowlight
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_static_data_type  afd_static_lowlight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_scd_normal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_scd_data_type     afd_scd_normal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// afd_scd_lowlight
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_afd_scd_data_type     afd_scd_lowlight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_auto_flicker_detection_data_typeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatix_auto_flicker_detection_data_typeClass : public ParameterModule, public chromatix_auto_flicker_detection_data_type
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 1;
    static const UINT16 MINOR = 0;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_auto_flicker_detection_data_typeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_auto_flicker_detection_data_typeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatix_auto_flicker_detection_data_typeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load trigger_point_type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadtrigger_point_type(
        ParameterFileSymbolTableEntry* entry,
        trigger_point_type* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatix_afd_rolling_data_type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadchromatix_afd_rolling_data_type(
        ParameterFileSymbolTableEntry* entry,
        chromatix_afd_rolling_data_type* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatix_afd_scd_data_type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadchromatix_afd_scd_data_type(
        ParameterFileSymbolTableEntry* entry,
        chromatix_afd_scd_data_type* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatix_afd_static_data_type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadchromatix_afd_static_data_type(
        ParameterFileSymbolTableEntry* entry,
        chromatix_afd_static_data_type* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatix_auto_flicker_detection_data_type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadchromatix_auto_flicker_detection_data_type(
        ParameterFileSymbolTableEntry* entry,
        chromatix_auto_flicker_detection_data_type* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatix_auto_flicker_detection_data_type::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatix_auto_flicker_detection_data_typeClass

AFDTUNING_NAMESPACE_END
#endif // AFDTUNING_H

